{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 01. DQN\n",
    "\n",
    "[V. Mnih et al., \"Human-level control through deep reinforcement learning.\" Nature, 518\n",
    "(7540):529–533, 2015.](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)\n",
    "\n",
    "Reinforcement learning is known to be unstable or even to diverge when a nonlinear function approximator such as a neural network is used to represent the action-value (also known as $Q$) function. This instability has several causes: the correlations present in the sequence of observations, the fact that small updates to $Q$ may significantly change the policy and therefore change the data distribution, and the correlations between the action-values ($Q$) and the target values $r + \\gamma \\max_{a'} Q(s', a')$.\n",
    "\n",
    "The authors suggest two key ideas to address these instabilities with a novel variant of Q-learning: Replay buffer and Fixed Q-target.\n",
    "\n",
    "#### Uniformly random sampling from Experience Replay Memory\n",
    "\n",
    "Reinforcement learning agent stores the experiences consecutively in the buffer, so adjacent ($s, a, r, s'$) transitions stored are highly likely to have correlation. To remove this, the agent samples experiences uniformly at random from the pool of stored samples $\\big( (s, a, r, s') \\sim U(D) \\big)$. See sample_batch method of ReplayBuffer class for more details.\n",
    "\n",
    "#### Fixed Q-target\n",
    "\n",
    "DQN uses an iterative update that adjusts the action-values ($Q$) towards target values that are only periodically updated, thereby reducing correlations with the target; if not, it is easily divergy because the target continuously moves. The Q-learning update at iteration $i$ uses the following loss function:\n",
    "\n",
    "$$\n",
    "L_i(\\theta_i) = \\mathbb{E}_{(s,a,r,s') \\sim U(D)} \\big[ \\big( r + \\gamma \\max_{a'} Q(s',a';\\theta_i^-) - Q(s, a; \\theta_i) \\big)^2 \\big]\n",
    "$$\n",
    "\n",
    "in which $\\gamma$ is the discount factor determining the agent’s horizon, $\\theta_i$ are the parameters of the Q-network at iteration $i$ and $\\theta_i^-$ are the network parameters used to compute the target at iteration $i$. The target network parameters $\\theta_i^-$ are only updated with the Q-network parameters ($\\theta_i$) every C steps and are held fixed between individual updates. ($C = 200$ in CartPole-v0)\n",
    "\n",
    "#### For more stability: Gradient clipping\n",
    "\n",
    "The authors also found it helpful to clip the error term from the update $r + \\gamma \\max_{a'} Q(s', a'; \\theta_i^-) - Q(s,a,;\\theta_i)$ to be between -1 and 1. Because the absolute value loss function $|x|$ has a derivative of -1 for all negative values of x and a derivative of 1 for all positive values of x, clipping the squared error to be between -1 and 1 corresponds to using an absolute value loss function for errors outside of the (-1,1) interval. This form of error clipping further improved the stability of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "  - collections.deque\n",
    "  - list\n",
    "  - numpy.ndarray\n",
    "  \n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of  *Get item* is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference). Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "\n",
    "Reference: [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            self.env.render()\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(\n",
    "            next_state\n",
    "        ).max(dim=1, keepdim=True)[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "agent.env = gym.wrappers.Monitor(env, \"videos\", force=True)\n",
    "agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "videos/openaigym.video.0.13069.video000000.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "latest_file = max(list_of_files, key=os.path.getctime)\n",
    "print(latest_file)\n",
    "ipython_show_video(latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
